package me.jollyfly.jshop.user.server.controller

import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.annotation.JsonIgnoreProperties
import lombok.extern.slf4j.Slf4j
import me.jollyfly.jshop.common.bean.ResultBean
import me.jollyfly.jshop.common.constant.SystemConstant.UserServiceConstant.CHECK_TYPE_EMAIL
import me.jollyfly.jshop.common.constant.SystemConstant.UserServiceConstant.CHECK_TYPE_PHONE
import me.jollyfly.jshop.common.constant.SystemConstant.UserServiceConstant.CHECK_TYPE_USERNAME
import me.jollyfly.jshop.framework.aop.LogRecord
import me.jollyfly.jshop.user.client.exception.CheckException
import me.jollyfly.jshop.user.client.model.UserDO
import me.jollyfly.jshop.user.server.dao.UserDAO
import org.springframework.beans.BeanUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.util.DigestUtils
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RestController
import java.util.*

/**
 * @author jollyfly
 */
@RestController
@Slf4j
open class UserController {


    @Autowired
    private var userDAO: UserDAO? = null


    /**
     * 请求格式 GET
     * 注册数据校验
     *
     * @param data 校验数据
     * @param type 类型 可选参数1、2、3分别代表username、phone、email
     *
     * @return {
     * code: 1 //1 成功 2 失败 3 无权限
     * msg: "success"
     * data: false // 返回数据，true：数据可用，false：数据不可用
     * }
     */
    @LogRecord("注册数据校验")
    @GetMapping("/server/user/check")
    fun checkUserDate(data: String, type: String): ResultBean<Boolean> {
        val userDO = UserDO()
        when (type) {
            CHECK_TYPE_USERNAME -> userDO.username = data
            CHECK_TYPE_PHONE -> userDO.phone = data
            CHECK_TYPE_EMAIL -> userDO.email = data
            else -> throw CheckException("数据校验类型只能是：" + CHECK_TYPE_USERNAME + "、" + CHECK_TYPE_PHONE + "、" +
                    CHECK_TYPE_EMAIL + "中的一种")
        }
        val userLists = this.userDAO!!.select(userDO)

        return if (userLists != null && userLists.size > 0) {
            ResultBean(java.lang.Boolean.FALSE)
        } else ResultBean(java.lang.Boolean.TRUE)
    }

    /**
     * 请求格式 POST
     * 用户注册
     *
     * @param user User POJO Json
     *
     * @return {
     * status: 200 //200 成功 400 数据错误 500 系统异常
     * msg: "OK" //错误 注册失败. 请校验数据后请再提交数据.
     * data: null
     * }
     */

    @PostMapping("/server/user/")
    fun regist(user: UserDO?): ResultBean<UserDO> {

        if (user == null) {
            return ResultBean(null, ResultBean.FAIL, "user不能为空！")
        }
        user.password = DigestUtils.md5DigestAsHex(user.password.toByteArray())
        user.created = Date()
        user.updated = Date()
        val userDO = UserDO()
        BeanUtils.copyProperties(user, userDO)
        this.userDAO!!.insertSelective(userDO)
        return ResultBean(user)
    }


    /**
     * 请求格式 POST
     * 用户登录
     *
     * @param user Tbuser POJO Json
     *
     * @return {
     * status: 200 //200 成功 400 登录失败 500 系统异常
     * msg: "OK" //错误 用户名或密码错误,请检查后重试.
     * data: "fe5cb546aeb3ce1bf37abcb08a40493e" //登录成功，返回token
     * }
     */

    //    @PostMapping("/server/user/login")
    //    public JshopResult login(User user) {
    //
    //        if (user == null) {
    //            return new JshopResult(400, "user不能为空！", null);
    //        }
    //        UserDO userDO = new UserDO();
    //        BeanUtils.copyProperties(user, userDO);
    //        Example<UserDO> userEntityExample = Example.of(userDO);
    //
    //        List<UserDO> userEntities = userRepo.findAll(userEntityExample);
    //
    //        if (userEntities == null || userEntities.size() == 0) {
    //            return new JshopResult(400, "用户名不存在", null);
    //        }
    //
    //        UserDO check = userEntities.get(0);
    //
    //        if (!check.getPassword().equals(DigestUtils.md5DigestAsHex(user.getPassword().getBytes()))) {
    //            return new JshopResult(401, "用户名或密码错误", null);
    //        }
    //
    //        String token = UUID.randomUUID().toString().replaceAll("-", "");
    //
    //        return new JshopResult(token);
    //    }

    /**
     * 请求格式 GET
     * 根据token值获取用户信息
     *
     * @param token token值
     *
     * @return {
     * status: 200 //200 成功 400 没有此token 500 系统异常
     * msg: "OK" //错误 没有此token.
     * data: {"username":"xbin","id":"id"} //返回用户名
     * }
     */
    //    @GetMapping("/server/user/token")
    //    public JshopResult token(String token) {
    //        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    //        User u = (User) operations.get(token);
    //        return new JshopResult(u);
    //    }

    /**
     * 请求格式 GET
     * 根据token值 退出登录
     *
     * @param token token值
     *
     * @return {
     * status: 200 //200 成功 400 没有此token 500 系统异常
     * msg: "OK" //错误 没有此token.
     * data: null
     * }
     */
    //    @GetMapping("/server/user/logout")
    //    public JshopResult logout(String token) {
    //        if (redisTemplate.hasKey(token)) {
    //            redisTemplate.delete(token);
    //        }
    //        return new JshopResult(Boolean.TRUE);
    //    }

    /**
     * 请求格式 POST
     * 验证验证码
     *
     * @param authCode 输入的验证码
     * @param uuid     Redis验证码uuid
     * @return {
     * "success": 0 可用 1 不可用
     * }
     */
    //    public String validateAuthCode(String authCode, String uuid) {
    //
    //        HashMap<String, Integer> map = new HashMap<>();
    //
    //        try {
    //            String redisAuthCode = jedisClient.get(VERIFYCODE + uuid);
    //
    //            if (StringUtils.isBlank(redisAuthCode)) {
    //
    //                map.put(KEY, ERROR);
    //
    //                logger.info("Redis中根据key查询不到");
    //
    //                return FastJsonConvert.convertObjectToJSON(map);
    //            }
    //
    //            if (StringUtils.isBlank(authCode)) {
    //                map.put(KEY, ERROR);
    //
    //                logger.info("验证码为空");
    //
    //                return FastJsonConvert.convertObjectToJSON(map);
    //            }
    //
    //            if (redisAuthCode.equalsIgnoreCase(authCode)) {
    //
    //                map.put(KEY, SUCCESS);
    //
    //                return FastJsonConvert.convertObjectToJSON(map);
    //            }
    //
    //
    //        } catch (Exception e) {
    //
    //            logger.error("redis 服务出错", e);
    //
    //        }
    //
    //        map.put(KEY, ERROR);
    //
    //        return FastJsonConvert.convertObjectToJSON(map);
    //    }
    //
    //    /**
    //     * 请求格式 POST
    //     * 注册
    //     *
    //     * @param regName    注册名
    //     * @param pwd        第一次密码
    //     * @param pwdRepeat  第二次密码
    //     * @param phone      电话
    //     * @param mobileCode 手机验证码
    //     * @param email      邮箱
    //     * @param authCode   输入的验证码
    //     * @param uuid       Redis验证码uuid
    //     * @return
    //     */
    //    @Override
    //    public String register(String regName, String pwd, String pwdRepeat, String phone, String mobileCode, String
    //            uuid, String authCode, String email) {
    //
    //        if (!pwd.equals(pwdRepeat)) {
    //
    //            String info = "两次密码不正确";
    //            return "({'info':'" + info + "'})";
    //
    //        }
    //
    //        if (StringUtils.isNotBlank(authCode)) {
    //
    //            String code = "";
    //            try {
    //                code = jedisClient.get(VERIFYCODE + uuid);
    //            } catch (Exception e) {
    //
    //                logger.error("Redis服务出错", e);
    //
    //            }
    //            //if (StringUtils.isBlank(code)) {
    //            //    String info = "验证码不正确或已过期，请重新获取";
    //            //    String convert = ConvertUtils.convert(info);
    //            //    return "({'info':'" + convert + "'})";
    //            //}
    //
    //            if (StringUtils.isBlank(code) || !code.equalsIgnoreCase(authCode)) {
    //
    //                String info = "验证码不正确或已过期，请重新获取";
    //                return "({'info':'" + info + "'})";
    //
    //            }
    //
    //        } else {
    //
    //            String info = "验证码不能为空";
    //            return "({'info':'" + info + "'})";
    //
    //        }
    //
    //        if (StringUtils.isNotBlank(phone)) {
    //            String phone2 = phone.substring(5, phone.length());
    //            String phonecode = "";
    //            try {
    //                phonecode = jedisClient.get(MOBILE_LOGIN_CODE + phone2);
    //            } catch (Exception e) {
    //                logger.error("Redis服务出错");
    //            }
    //
    //            if (StringUtils.isBlank(phonecode) || !phonecode.equals(mobileCode)) {
    //
    //                String info = "短信验证码不正确或已过期,请重新获取";
    //                return "({'info':'" + info + "'})";
    //
    //            }
    //        } else {
    //            String info = "手机号码不能为空";
    //            return "({'info':'" + info + "'})";
    //        }
    //
    //        if (StringUtils.isNotBlank(regName)) {
    //
    //            TbUser user = new TbUser();
    //            user.setUsername(regName);
    //            user.setPassword(DigestUtils.md5DigestAsHex(pwd.getBytes()));
    //            user.setPhone(phone);
    //
    //            user.setCreated(new Date());
    //            user.setUpdated(new Date());
    //
    //            if (StringUtils.isNotBlank(email)) {
    //                user.setEmail(email);
    //            }
    //
    //            userMapper.insert(user);
    //            //注册成功 忽略noAuth这个词
    //            return "({'noAuth':'" + SUCCESS_URL + "?username=" + regName + "'})";
    //        }
    //        //注册失败
    //        return "({'error':1})";
    //
    //
    //    }
}
